;void borrar(Lista* la_lista, Uint32 x, Uint32 y);

%include "nodo.mac"

extern free

global borrar

%define p_lista [ebp + 8]
%define x [ebp + 12]
%define y [ebp + 16]
%define rango 50

section .text

borrar:
	push ebp
	mov ebp, esp
	push edi
	push esi
	push ebx
	
	mov ecx, p_lista ; Muevo a ecx el puntero de la lista.
	mov edi, [ecx] ; Muevo a edi el puntero al primer nodo.
	
	cmp edi, 0 ; Me fijo si el puntero al primer nodo es null
	jne cicloBorrar ; Si no es comienzo con borrar.
	jmp fin ; Sino termine
	
cicloBorrar:	
	
	cmp edi, 0 ; me fijo si el nodo es null
	jne seteoCotaY
	jmp fin ; termine de recorrer
	
seteoCotaY: ; A continuacion voy a setear la cota inferior de la "y".

cotaInferiorY:
	mov esi, y ; Muevo la coord_y a esi.
	cmp esi, rango ; Comparo a esi con el rango.
	jb pongo_cero_en_y ; Si es menor pongo en cero la cota inferior de la "y".
	jmp continuarY ; Sino le resto el rango a la cota inferior.

pongo_cero_en_y: ; Pongo en cero la cotar inferior de la "y".
	xor esi, esi
	jmp seteoCotaX
	
continuarY: ; Le resto el rango a la cota inferior de la "y".
	sub esi, rango
	
seteoCotaX: ; A continuacion voy a setear la cota inferior de la "x".
	
cotaInferiorX:
	mov ebx, x ; Muevo la "x" a ebx.
	cmp ebx, rango ; Comparo a ebx con el rango.
	jb pongo_cero_en_x ; Si es menor pongo en cero la cota inferior de la "x".
	jmp continuarX ; Sino le resto el rango a la cota inferior.
	
pongo_cero_en_x: ; Pongo en cero la cotar inferior de la "x".
	xor ebx, ebx
	jmp cotaSuperiorX
	
continuarX: ; Le resto el rango a la cota inferior de la "x".
	sub ebx, rango
	
cotaSuperiorX:
	mov eax, x ; Muevo la "x" a eax.
	add eax, rango ; Le sumo el rango.

comparoX:
	xor edx, edx ; Limpio edx.
	mov edx, [edi + off_coord_x] ; Muevo la coord_x del primer nodo a edx.
	cmp edx, ebx ; Comparo con la cota inferior de "x" que esta en ebx.
	jb continuar ; Si es menor no esta dentro del rango.
	jmp next ; Sino verifico mas cotas.

continuar:
	mov ebx, [edi + off_p_prox]
	mov edi, ebx
	jmp cicloBorrar

next:
	cmp edx, eax ; Comparo con la cota superior de "x"
	ja continuar ; Si es mayor no esta dentro del rango
	cmp [edi + off_coord_y], esi ; Sino comparo la coord_y con la cota inferior de "y"
	jb continuar ; Si es menor esta fuera del rango.
	mov edx, y ; Sino calculo la cota superior de "y". Muevo "y" a edx.
	add edx, rango ; Tengo en edx la cota superior de "y".
	cmp [edi + off_coord_y], edx ; Comparo la coord_y con la cota superior de "y".
	ja continuar ; Si es mayor esta fuera del rango.
	
borra_en_rango:
	mov ebx, [edi + off_p_prox]; guardo en ebx el nodo siguiente.
	mov eax, [edi + off_p_prev] ; guardo en eax el nodo anterior.
	cmp eax, 0 ; es el primero?
	je primero
	
	mov [eax+off_p_prox], ebx ; edi->ant->sig = edx
	cmp ebx, 0 ; si el proximo es null reapunto punteros de otro forma
	je sinProximo	
	mov [ebx+off_p_prev], eax ; 
	push edi
	call free
	add esp , 4 
	mov edi, ebx ; Es edi tengo puntero a nodo => en edi tengo el puntero actual	
	jmp cicloBorrar
	
primero:
	mov [ecx], ebx; el contenido de p_lista = ebx (el primer nodo)	
	cmp ebx, 0 ; si el proximo es null reapunto punteros de otro forma	
	je sinProximo			
	push edi
	call free
	add esp , 4
	mov dword [ebx + off_p_prev], 0
	mov edi, ebx ; Es edi tengo puntero a nodo => en edi tengo el puntero actual	
	jmp cicloBorrar
	
sinProximo:
	;mov edx, ebx 
	push edi
	call free
	add esp , 4 
	jmp fin
	
fin:
	pop ebx
	pop esi
	pop edi
	pop ebp
	ret
